home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume15 / dmake-3.6 / part04 < prev    next >
Encoding:
Text File  |  1990-10-14  |  39.0 KB  |  1,556 lines
  1. Newsgroups: comp.sources.misc
  2. X-UNIX-From: dvadura@watdragon.waterloo.edu
  3. subject: v15i056: dmake version 3.6 (part 04/25)
  4. from: Dennis Vadura <dvadura@watdragon.waterloo.edu>
  5. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  6.  
  7. Posting-number: Volume 15, Issue 56
  8. Submitted-by: Dennis Vadura <dvadura@watdragon.waterloo.edu>
  9. Archive-name: dmake-3.6/part04
  10.  
  11. #!/bin/sh
  12. # this is part 4 of a multipart archive
  13. # do not concatenate these parts, unpack them in order with /bin/sh
  14. # file unix/arlib.c continued
  15. #
  16. CurArch=4
  17. if test ! -r s2_seq_.tmp
  18. then echo "Please unpack part 1 first!"
  19.      exit 1; fi
  20. ( read Scheck
  21.   if test "$Scheck" != $CurArch
  22.   then echo "Please unpack part $Scheck next!"
  23.        exit 1;
  24.   else exit 0; fi
  25. ) < s2_seq_.tmp || exit 1
  26. echo "x - Continuing file unix/arlib.c"
  27. sed 's/^X//' << 'SHAR_EOF' >> unix/arlib.c
  28. X   fread( (char*)&word, sizeof(word), 1, f );
  29. X   if( word != ARMAG ) return( -1 );
  30. X#endif
  31. X
  32. X   /* scan the library, calling `function' for each member
  33. X    */
  34. X   while( 1 ) {
  35. X      if( fread((char*) &arhdr, sizeof(arhdr), 1, f) != 1 ) break;
  36. X      offset = ftell(f);
  37. X      strncpy(_ar.ar_name, arhdr.ar_name, sizeof(arhdr.ar_name));
  38. X
  39. X      for( p = &_ar.ar_name[sizeof(arhdr.ar_name)];
  40. X           --p >= _ar.ar_name && *p == ' ';);
  41. X
  42. X      p[1] = '\0';
  43. X      if( *p == '/' ) *p = 0;     /* Only SysV has trailing '/' */
  44. X
  45. X#if ASCARCH
  46. X      if( strncmp(arhdr.ar_fmag, ARFMAG, sizeof(arhdr.ar_fmag)) != 0 )
  47. X         return( -1 );
  48. X      _ar.ar_time = atol(arhdr.ar_date);
  49. X      _ar.ar_size = atol(arhdr.ar_size);
  50. X#else
  51. X      _ar.ar_time = arhdr.ar_date;
  52. X      _ar.ar_size = arhdr.ar_size;
  53. X#endif
  54. X
  55. X
  56. X#if DECODE_ALL_AR_FIELDS
  57. X#if ASCARCH
  58. X      _ar.ar_mode = atoi(arhdr.ar_mode);
  59. X      _ar.ar_uid  = atoi(arhdr.ar_uid);
  60. X      _ar.ar_gid  = atoi(arhdr.ar_gid);
  61. X#else
  62. X      _ar.ar_mode = arhdr.ar_mode;
  63. X      _ar.ar_size = arhdr.ar_size;
  64. X      _ar.ar_uid = arhdr.ar_uid;
  65. X      _ar.ar_gid = arhdr.ar_gid;
  66. X#endif
  67. X#endif
  68. X
  69. X      if( (*function)(f, &_ar, arg) ) return( 1 );
  70. X      fseek( f, offset + (_ar.ar_size+1 & ~1L), 0 );
  71. X   }
  72. X
  73. X   if( !feof(f) ) return( -1 );
  74. X   return 0;
  75. X}
  76. X
  77. X
  78. X
  79. Xstatic int
  80. Xar_touch( f, now )/*
  81. X====================
  82. X   touch module header timestamp. */
  83. XFILE   *f;
  84. Xtime_t now;
  85. X{
  86. X   struct ar_hdr arhdr;                /* external archive header */
  87. X
  88. X   fseek(f, - (off_t) (sizeof(arhdr) - sizeof(arhdr.ar_name)), 1);
  89. X
  90. X#if ASCARCH
  91. X   fprintf(f, "%lu", now);
  92. X#else
  93. X   fwrite((char *)now, sizeof(now), 1, f);
  94. X#endif
  95. X
  96. X   return( ferror(f) ? 0 : 1 );
  97. X}
  98. X
  99. X
  100. X#if LC
  101. Xtypedef struct mem {
  102. X   time_t    m_time;        /* modify time of member*/
  103. X   struct mem    *m_next;    /* next member in lib    */
  104. X   char        m_valid;    /* valid cache entry    */
  105. X   char     m_name[1];    /* lib member name    */
  106. X} MEM, *MEMPTR;
  107. X
  108. Xtypedef struct lib {
  109. X   struct lib    *lb_next;    /* next library in list */
  110. X   struct mem    *lb_members;    /* list of lib members    */
  111. X   char        lb_valid;    /* valid cache entry    */
  112. X   char     *lb_name;    /* library name        */
  113. X} LIB, *LIBPTR;
  114. X
  115. Xstatic LIBPTR _cache = NIL(LIB);
  116. Xstatic MEMPTR _find_member ANSI(( LIBPTR, char * ));
  117. X
  118. Xstatic int
  119. X_check_cache( name, lib, pmtime, touch )/*
  120. X==========================================
  121. X   Check to see if we have cached member in lib, if so return time in pmtime
  122. X   and return TRUE, otherwise return FALSE, if touch is TRUE then touch
  123. X   the archive member instead. */
  124. Xchar   *name;
  125. Xchar   *lib;
  126. Xtime_t *pmtime;
  127. Xint    touch;
  128. X{
  129. X   register MEMPTR mp;
  130. X   register LIBPTR lp;
  131. X
  132. X   for( lp=_cache; lp != NIL(LIB) && lp->lb_name != lib; lp=lp->lb_next );
  133. X   if( lp == NIL(LIB) ) return( FALSE );
  134. X
  135. X   mp = _find_member( lp, name );
  136. X   if( mp == NIL(MEM) || !mp->m_valid ) return( FALSE );
  137. X
  138. X   if( touch == TRUE )
  139. X   {
  140. X      mp->m_time = *pmtime;
  141. X      mp->m_valid = 1;
  142. X   }
  143. X   else
  144. X      *pmtime = mp->m_time;
  145. X
  146. X   lp->lb_valid   = 1;
  147. X   lp->lb_members = mp;
  148. X
  149. X   return( TRUE );
  150. X}
  151. X
  152. X
  153. X
  154. Xstatic int
  155. X_cache_member( name, lib, mtime )/*
  156. X===================================
  157. X   Cache name in lib along with it's time */
  158. Xchar   *name;
  159. Xchar   *lib;
  160. Xtime_t mtime;
  161. X{
  162. X   register MEMPTR mp;
  163. X   register LIBPTR lp;
  164. X
  165. X   for( lp=_cache;
  166. X    lp != NIL(LIB) && lp->lb_name != NIL(char) && lp->lb_name != lib;
  167. X    lp=lp->lb_next);
  168. X
  169. X   if( lp == NIL(LIB) )
  170. X   {
  171. X      lp = (LIBPTR) malloc(sizeof(LIB));
  172. X      if( lp == NIL(LIB) ) No_ram();
  173. X
  174. X      lp->lb_name    = lib;
  175. X      lp->lb_members = NIL(MEM);
  176. X      lp->lb_next    = _cache;
  177. X      lp->lb_valid   = 0;
  178. X      _cache = lp;
  179. X   }
  180. X
  181. X   /* On UNIX ar does not allow multiple copies of the same .o file to live
  182. X    * in the same AR file.  If this is not TRUE then use the commented out
  183. X    * version to set the value of mp. */
  184. X
  185. X   /*mp = _find_member(lp, name);*/
  186. X   mp = NIL(MEM);
  187. X
  188. X   if( mp == NIL(MEM) )
  189. X   {
  190. X      mp = (MEMPTR) malloc(sizeof(char)*offsetof(MEM,m_name[strlen(name)+1]));
  191. X      if( mp == NIL(MEM) ) No_ram();
  192. X
  193. X      strcpy( mp->m_name, name );
  194. X      mp->m_time     = mtime;
  195. X
  196. X      if( lp->lb_members == NIL(MEM) ) {
  197. X     mp->m_next     = mp;
  198. X     lp->lb_members = mp;
  199. X      }
  200. X      else {
  201. X     mp->m_next = lp->lb_members->m_next;
  202. X     lp->lb_members->m_next = mp;
  203. X     lp->lb_members = mp;
  204. X      }
  205. X   }
  206. X   else
  207. X      mp->m_time = mtime;
  208. X
  209. X   mp->m_valid = 1;
  210. X
  211. X   return( lp->lb_valid );
  212. X}
  213. X
  214. X
  215. Xstatic MEMPTR
  216. X_find_member( lp, name )
  217. XLIBPTR lp;
  218. Xchar   *name;
  219. X{
  220. X   register MEMPTR mp = lp->lb_members;
  221. X
  222. X   if( mp == NIL(MEM) ) return(mp);
  223. X
  224. X   do {
  225. X      if( !strcmp(mp->m_name, name ) ) return( mp );
  226. X      mp = mp->m_next;
  227. X   }
  228. X   while( mp != lp->lb_members );
  229. X
  230. X   return( NIL(MEM) );
  231. X}
  232. X#endif
  233. X
  234. X
  235. X
  236. Xvoid
  237. Xvoid_lcache( lib, member )/*
  238. X============================
  239. X   Void the library cache for lib.  If member is NIL(char) then nuke all
  240. X   of the members, if member is NOT NIL(char) then invalidate only that
  241. X   member. */
  242. Xchar *lib;
  243. Xchar *member;
  244. X{
  245. X#if LC
  246. X   register LIBPTR lp;
  247. X   register MEMPTR mp;
  248. X   register MEMPTR tmp;
  249. X
  250. X   for( lp=_cache; lp != NIL(LIB) && lp->lb_name != lib; lp=lp->lb_next );
  251. X   if( lp == NIL(LIB) ) return;
  252. X
  253. X   if( member == NIL(char) ) {
  254. X      mp = lp->lb_members;
  255. X      do {
  256. X     tmp = mp->m_next;
  257. X     (void) free( mp );
  258. X     mp = tmp;
  259. X      } while( mp != lp->lb_members );
  260. X
  261. X      lp->lb_valid   = 0;
  262. X      lp->lb_members = NIL(MEM);
  263. X      lp->lb_name    = NIL(char);
  264. X   }
  265. X   else {
  266. X      mp=lp->lb_members;
  267. X      do {
  268. X     if( strcmp( member, mp->m_name) == 0 ) {
  269. X        lp->lb_members = mp->m_next;
  270. X        mp->m_valid = 0;
  271. X     }
  272. X       
  273. X     mp=mp->m_next;
  274. X      } while( mp != lp->lb_members );
  275. X   }
  276. X#endif
  277. X}
  278. SHAR_EOF
  279. echo "File unix/arlib.c is complete"
  280. chmod 0440 unix/arlib.c || echo "restore of unix/arlib.c fails"
  281. echo mkdir - unix/386ix
  282. mkdir unix/386ix
  283. echo "x - extracting unix/386ix/time.h (Text)"
  284. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/time.h &&
  285. X/*
  286. X** Berkeley get this wrong!
  287. X*/
  288. X#ifndef    TIME_h
  289. X#define    TIME_h
  290. X
  291. Xtypedef    long    time_t;    /* this is the thing we use */
  292. X
  293. X#endif    TIME_h
  294. X
  295. SHAR_EOF
  296. chmod 0440 unix/386ix/time.h || echo "restore of unix/386ix/time.h fails"
  297. echo "x - extracting unix/386ix/stdlib.h (Text)"
  298. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/stdlib.h &&
  299. X#ifndef _STDLIB_INCLUDED_
  300. X#define _STDLIB_INCLUDED_
  301. X
  302. Xextern /*GOTO*/ _exit();
  303. Xextern /*GOTO*/ exit();
  304. Xextern /*GOTO*/ abort();
  305. Xextern int system();
  306. Xextern char *getenv();
  307. Xextern char *calloc();
  308. Xextern char *malloc();
  309. Xextern char *realloc();
  310. Xextern free();
  311. Xextern int errno;
  312. X
  313. X#ifndef EIO
  314. X#    include <errno.h>
  315. X#endif
  316. X
  317. X#endif /* _STDLIB_INCLUDED_ */
  318. SHAR_EOF
  319. chmod 0440 unix/386ix/stdlib.h || echo "restore of unix/386ix/stdlib.h fails"
  320. echo "x - extracting unix/386ix/stdarg.h (Text)"
  321. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/stdarg.h &&
  322. X/*
  323. X * stdarg.h
  324. X *
  325. X * defines ANSI style macros for accessing arguments of a function which takes
  326. X * a variable number of arguments
  327. X *
  328. X */
  329. X
  330. X#if !defined(__STDARG)
  331. X#define __STDARG
  332. X
  333. Xtypedef char *va_list;
  334. X
  335. X#define va_dcl int va_alist
  336. X#define va_start(ap,v)  ap = (va_list)&va_alist
  337. X#define va_arg(ap,t)    ((t*)(ap += sizeof(t)))[-1]
  338. X#define va_end(ap)      ap = NULL
  339. X#endif
  340. SHAR_EOF
  341. chmod 0440 unix/386ix/stdarg.h || echo "restore of unix/386ix/stdarg.h fails"
  342. echo "x - extracting unix/386ix/startup.mk (Text)"
  343. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/startup.mk &&
  344. X# Generic UNIX DMAKE startup file.  Customize to suit your needs.
  345. X# Should work for both SYSV, and BSD 4.3
  346. X# See the documentation for a description of internally defined macros.
  347. X#
  348. X# Disable warnings for macros redefined here that were given
  349. X# on the command line.
  350. X__.SILENT := $(.SILENT)
  351. X.SILENT   := yes
  352. X
  353. X# Configuration parameters for DMAKE startup.mk file
  354. X# Set these to NON-NULL if you wish to turn the parameter on.
  355. X_HAVE_RCS    := yes        # yes => RCS  is installed.
  356. X_HAVE_SCCS    := yes        # yes => SCCS is installed.
  357. X
  358. X# Applicable suffix definitions
  359. XA := .a        # Libraries
  360. XE :=        # Executables
  361. XF := .f        # Fortran
  362. XO := .o        # Objects
  363. XP := .p        # Pascal
  364. XS := .s        # Assembler sources
  365. XV := ,v        # RCS suffix
  366. X
  367. X# Recipe execution configurations
  368. XSHELL        := /bin/sh
  369. XSHELLFLAGS    := -ce
  370. XGROUPSHELL    := $(SHELL)
  371. XGROUPFLAGS    := 
  372. XSHELLMETAS    := |();&<>?*][$$:\\#`'"
  373. XGROUPSUFFIX    :=
  374. XDIVFILE         = $(TMPFILE)
  375. X
  376. X# Standard C-language command names and flags
  377. X   CPP       := /lib/cpp        # C-preprocessor
  378. X   CC      := cc        # C-compiler and flags
  379. X   CFLAGS  +=
  380. X
  381. X   AS      := as        # Assembler and flags
  382. X   ASFLAGS += 
  383. X
  384. X   LD       = $(CC)        # Loader and flags
  385. X   LDFLAGS +=
  386. X   LDLIBS   =
  387. X
  388. X# Definition of $(MAKE) macro for recursive makes.
  389. X   MAKE = $(MAKECMD) $(MFLAGS)
  390. X
  391. X# Definition of Print command for this system.
  392. X   PRINT = lpr
  393. X
  394. X# Language and Parser generation Tools and their flags
  395. X   YACC      := yacc        # standard yacc
  396. X   YFLAGS +=
  397. X   YTAB      := y.tab        # yacc output files name stem.
  398. X
  399. X   LEX      := lex        # standard lex
  400. X   LFLAGS +=
  401. X   LEXYY  := lex.yy        # lex output file
  402. X
  403. X# Other Compilers, Tools and their flags
  404. X   PC    := pc            # pascal compiler
  405. X   RC    := f77            # ratfor compiler
  406. X   FC    := f77            # fortran compiler
  407. X
  408. X   CO       := co        # check out for RCS
  409. X   COFLAGS += -q
  410. X
  411. X   AR     := ar            # archiver
  412. X   ARFLAGS+= ruv
  413. X
  414. X   RM       := /bin/rm        # remove a file command
  415. X   RMFLAGS +=
  416. X
  417. X# Implicit generation rules for making inferences.
  418. X# We don't provide .yr or .ye rules here.  They're obsolete.
  419. X# Rules for making *$O
  420. X   %$O : %.c ; $(CC) $(CFLAGS) -c $<
  421. X   %$O : %$P ; $(PC) $(PFLAGS) -c $<
  422. X   %$O : %$S ; $(AS) $(ASFLAGS) $<
  423. X   %$O : %.cl ; class -c $<
  424. X   %$O : %.e %.r %.F %$F
  425. X    $(FC) $(RFLAGS) $(EFLAGS) $(FFLAGS) -c $<
  426. X
  427. X# Executables
  428. X   %$E : %$O ; $(LD) $(LDFLAGS) -o $@ $< $(LDLIBES)
  429. X
  430. X# lex and yacc rules
  431. X   %.c : %.y ; $(YACC)  $(YFLAGS) $<; mv $(YTAB).c $@
  432. X   %.c : %.l ; $(LEX)   $(LFLAGS) $<; mv $(LEXYY).c $@
  433. X
  434. X# This rule tells how to make *.out from it's immediate list of prerequisites
  435. X# UNIX only.
  436. X   %.out :; $(LD) $(LDFLAGS) -o $@ $^ $(LDLIBS)
  437. X
  438. X# RCS support
  439. X.IF $(_HAVE_RCS)
  440. X   % : %$V $$(@:d)RCS/$$(@:f)$V;- $(CO) $(COFLAGS) $@
  441. X   .NOINFER : %$V $$(@:d)RCS/$$(@:f)$V
  442. X.END
  443. X
  444. X# SCCS support
  445. X.IF $(_HAVE_SCCS)
  446. X   % : s.% ; get $@
  447. X   .NOINFER : s.%
  448. X.END
  449. X
  450. X# Recipe to make archive files.
  451. X%$A :
  452. X[
  453. X   $(AR) $(ARFLAGS) $@ $?
  454. X   $(RM) $(RMFLAGS) $?
  455. X   ranlib $@
  456. X]
  457. X
  458. X# DMAKE uses this recipe to remove intermediate targets
  459. X.REMOVE :; $(RM) -f $<
  460. X
  461. X# AUGMAKE extensions for SYSV compatibility
  462. X@B = $(@:b)
  463. X@D = $(@:d)
  464. X@F = $(@:f)
  465. X*B = $(*:b)
  466. X*D = $(*:d)
  467. X*F = $(*:f)
  468. X<B = $(<:b)
  469. X<D = $(<:d)
  470. X<F = $(<:f)
  471. X?B = $(?:b)
  472. X?F = $(?:f)
  473. X?D = $(?:d)
  474. X
  475. X# Turn warnings back to previous setting.
  476. X.SILENT := $(__.SILENT)
  477. X
  478. X# Local startup file if any
  479. X.INCLUDE .IGNORE: "_startup.mk"
  480. SHAR_EOF
  481. chmod 0640 unix/386ix/startup.mk || echo "restore of unix/386ix/startup.mk fails"
  482. echo "x - extracting unix/386ix/runargv.c (Text)"
  483. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/runargv.c &&
  484. X/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/unix/386ix/RCS/runargv.c,v 1.1 90/10/06 12:05:59 dvadura Exp $
  485. X-- SYNOPSIS -- invoke a sub process.
  486. X-- 
  487. X-- DESCRIPTION
  488. X--     Use the standard methods of executing a sub process.
  489. X--
  490. X-- AUTHOR
  491. X--      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  492. X--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  493. X--
  494. X-- COPYRIGHT
  495. X--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  496. X-- 
  497. X--      This program is free software; you can redistribute it and/or
  498. X--      modify it under the terms of the GNU General Public License
  499. X--      (version 1), as published by the Free Software Foundation, and
  500. X--      found in the file 'LICENSE' included with this distribution.
  501. X-- 
  502. X--      This program is distributed in the hope that it will be useful,
  503. X--      but WITHOUT ANY WARRANTY; without even the implied warrant of
  504. X--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  505. X--      GNU General Public License for more details.
  506. X-- 
  507. X--      You should have received a copy of the GNU General Public License
  508. X--      along with this program;  if not, write to the Free Software
  509. X--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  510. X--
  511. X-- LOG
  512. X--     $Log:    runargv.c,v $
  513. X * Revision 1.1  90/10/06  12:05:59  dvadura
  514. X * dmake Release, Version 3.6
  515. X * 
  516. X*/
  517. X
  518. X#include <signal.h>
  519. X#include "extern.h"
  520. X#include "sysintf.h"
  521. X#include "alloc.h"
  522. X
  523. Xtypedef struct prp {
  524. X   char *prp_cmd;
  525. X   int   prp_group;
  526. X   int   prp_ignore;
  527. X   int   prp_last;
  528. X   int     prp_shell;
  529. X   struct prp *prp_next;
  530. X   char  *prp_dir;
  531. X} RCP, *RCPPTR;
  532. X
  533. Xtypedef struct pr {
  534. X   int        pr_valid;
  535. X   int        pr_pid;
  536. X   CELLPTR    pr_target;
  537. X   HOWPTR    pr_how;
  538. X   int        pr_ignore;
  539. X   int        pr_last;
  540. X   RCPPTR      pr_recipe;
  541. X   RCPPTR      pr_recipe_end;
  542. X} PR;
  543. X
  544. Xstatic PR  *_procs    = NIL(PR);
  545. Xstatic int  _proc_cnt = 0;
  546. Xstatic int  _abort_flg= FALSE;
  547. Xstatic int  _use_i    = -1;
  548. Xstatic int  _do_upd   = 0;
  549. X
  550. Xstatic  void    _add_child ANSI((int, CELLPTR, HOWPTR, int, int));
  551. Xstatic  void    _attach_cmd ANSI((char *, int, int, CELLPTR, HOWPTR, int, int));
  552. Xstatic  void    _finished_child ANSI((int, int));
  553. Xstatic  int     _running ANSI((CELLPTR, HOWPTR));
  554. X
  555. Xint
  556. Xrunargv(target, how, ignore, group, last, shell, cmd)
  557. XCELLPTR target;
  558. XHOWPTR  how;
  559. Xint     ignore;
  560. Xint    group;
  561. Xint    last;
  562. Xint     shell;
  563. Xchar    *cmd;
  564. X{
  565. X   extern  int  errno;
  566. X   extern  char *sys_errlist[];
  567. X   int          pid;
  568. X   char         **argv;
  569. X
  570. X   if( _running(target, how) /*&& Max_proc != 1*/ ) {
  571. X      /* The command will be executed when the previous recipe
  572. X       * line completes. */
  573. X      _attach_cmd( cmd, group, ignore, target, how, last, shell );
  574. X      return(1);
  575. X   }
  576. X
  577. X   while( _proc_cnt == Max_proc )
  578. X      if( Wait_for_child(FALSE, -1) == -1 )  Fatal( "Lost a child" );
  579. X
  580. X   argv = Pack_argv( group, shell, cmd );
  581. X
  582. X   switch( pid=fork() ){
  583. X      int   wid;
  584. X      int   status;
  585. X
  586. X   case -1: /* fork failed */
  587. X      Error("%s: %s", argv[0], sys_errlist[errno]);
  588. X      Handle_result(-1, ignore, _abort_flg, target);
  589. X      return(-1);
  590. X
  591. X   case 0:  /* child */
  592. X      execvp(argv[0], argv);
  593. X      Continue = TRUE;   /* survive error message */
  594. X      Error("%s: %s", argv[0], sys_errlist[errno]);
  595. X      kill(getpid(), SIGTERM);
  596. X      /*NOTREACHED*/
  597. X
  598. X   default: /* parent */
  599. X      _add_child(pid, target, how, ignore, last);
  600. X   }
  601. X
  602. X   return(1);
  603. X}
  604. X
  605. X
  606. Xint
  607. XWait_for_child( abort_flg, pid )
  608. Xint abort_flg;
  609. Xint pid;
  610. X{
  611. X   int wid;
  612. X   int status;
  613. X   int waitchild;
  614. X
  615. X   waitchild = (pid == -1)? FALSE : Wait_for_completion;
  616. X
  617. X   do {
  618. X      if( (wid = wait(&status)) == -1 ) return(-1);
  619. X
  620. X      _abort_flg = abort_flg;
  621. X      _finished_child(wid, status);
  622. X      _abort_flg = FALSE;
  623. X   }
  624. X   while( waitchild && pid != wid );
  625. X
  626. X   return(0);
  627. X}
  628. X
  629. X
  630. Xvoid
  631. XClean_up_processes()
  632. X{
  633. X   register int i;
  634. X
  635. X   if( _procs != NIL(PR) ) {
  636. X      for( i=0; i<Max_proc; i++ )
  637. X     if( _procs[i].pr_valid )
  638. X        kill(_procs[i].pr_pid, SIGTERM);
  639. X
  640. X      while( Wait_for_child(TRUE, -1) != -1 );
  641. X   }
  642. X}
  643. X
  644. X
  645. Xstatic void
  646. X_add_child( pid, target, how, ignore, last )
  647. Xint    pid;
  648. XCELLPTR target;
  649. XHOWPTR  how;
  650. Xint    ignore;
  651. Xint     last;
  652. X{
  653. X   register int i;
  654. X   register PR *pp;
  655. X
  656. X   if( _procs == NIL(PR) ) {
  657. X      TALLOC( _procs, Max_proc, PR );
  658. X   }
  659. X
  660. X   if( (i = _use_i) == -1 )
  661. X      for( i=0; i<Max_proc; i++ )
  662. X     if( !_procs[i].pr_valid )
  663. X        break;
  664. X
  665. X   pp = _procs+i;
  666. X
  667. X   pp->pr_valid  = 1;
  668. X   pp->pr_pid    = pid;
  669. X   pp->pr_target = target;
  670. X   pp->pr_how    = how;
  671. X   pp->pr_ignore = ignore;
  672. X   pp->pr_last   = last;
  673. X
  674. X   Current_target = NIL(HOW);
  675. X
  676. X   _proc_cnt++;
  677. X
  678. X   if( Wait_for_completion ) Wait_for_child( FALSE, pid );
  679. X}
  680. X
  681. X
  682. Xstatic void
  683. X_finished_child(pid, status)
  684. Xint    pid;
  685. Xint    status;
  686. X{
  687. X   register int i;
  688. X   register PR *pp;
  689. X
  690. X   for( i=0; i<Max_proc; i++ )
  691. X      if( _procs[i].pr_valid && _procs[i].pr_pid == pid )
  692. X     break;
  693. X
  694. X   _procs[i].pr_valid = 0;
  695. X   _proc_cnt--;
  696. X
  697. X   if( _procs[i].pr_recipe != NIL(RCP) && !_abort_flg ) {
  698. X      RCPPTR rp = _procs[i].pr_recipe;
  699. X      char   *dir;
  700. X
  701. X      Current_target = _procs[i].pr_how;
  702. X      Handle_result( status, _procs[i].pr_ignore, FALSE, _procs[i].pr_target );
  703. X      Current_target = NIL(HOW);
  704. X
  705. X      _procs[i].pr_recipe = rp->prp_next;
  706. X
  707. X      _use_i = i;
  708. X      dir = _strdup(Get_current_dir());
  709. X      Set_dir( rp->prp_dir );
  710. X      runargv( _procs[i].pr_target, _procs[i].pr_how, rp->prp_ignore,
  711. X                 rp->prp_group, rp->prp_last, rp->prp_shell, rp->prp_cmd );
  712. X      Set_dir(dir);
  713. X      FREE(dir);
  714. X      FREE(rp->prp_dir);
  715. X      _use_i = -1;
  716. X
  717. X      FREE( rp->prp_cmd );
  718. X      FREE( rp );
  719. X
  720. X      if( _proc_cnt == Max_proc ) Wait_for_child( FALSE, -1 );
  721. X   }
  722. X   else {
  723. X      Unlink_temp_files( _procs[i].pr_how );
  724. X      Handle_result(status,_procs[i].pr_ignore,_abort_flg,_procs[i].pr_target);
  725. X
  726. X      if( _procs[i].pr_last && !Doing_bang )
  727. X     Update_time_stamp( _procs[i].pr_target, _procs[i].pr_how );
  728. X   }
  729. X}
  730. X
  731. X
  732. Xstatic int
  733. X_running( cp, how )
  734. XCELLPTR cp;
  735. XHOWPTR  how;
  736. X{
  737. X   register int i;
  738. X
  739. X   if( !_procs ) return(FALSE);
  740. X
  741. X   for( i=0; i<Max_proc; i++ )
  742. X      if( _procs[i].pr_valid &&
  743. X      _procs[i].pr_how == how &&
  744. X      _procs[i].pr_target == cp  )
  745. X     break;
  746. X     
  747. X   return( i != Max_proc );
  748. X}
  749. X
  750. X
  751. Xstatic void
  752. X_attach_cmd( cmd, group, ignore, cp, how, last, shell )
  753. Xchar    *cmd;
  754. Xint    group;
  755. Xint     ignore;
  756. XCELLPTR cp;
  757. XHOWPTR  how;
  758. Xint     last;
  759. Xint     shell;
  760. X{
  761. X   register int i;
  762. X   RCPPTR rp;
  763. X
  764. X   for( i=0; i<Max_proc; i++ )
  765. X      if( _procs[i].pr_valid &&
  766. X      _procs[i].pr_how == how &&
  767. X      _procs[i].pr_target == cp  )
  768. X     break;
  769. X
  770. X   TALLOC( rp, 1, RCP );
  771. X   rp->prp_cmd   = _strdup(cmd);
  772. X   rp->prp_group = group;
  773. X   rp->prp_ignore= ignore;
  774. X   rp->prp_last  = last;
  775. X   rp->prp_shell = shell;
  776. X   rp->prp_dir   = _strdup(Get_current_dir());
  777. X
  778. X   if( _procs[i].pr_recipe == NIL(RCP) )
  779. X      _procs[i].pr_recipe = _procs[i].pr_recipe_end = rp;
  780. X   else {
  781. X      _procs[i].pr_recipe_end->prp_next = rp;
  782. X      _procs[i].pr_recipe_end = rp;
  783. X   }
  784. X}
  785. SHAR_EOF
  786. chmod 0440 unix/386ix/runargv.c || echo "restore of unix/386ix/runargv.c fails"
  787. echo "x - extracting unix/386ix/make.sh (Text)"
  788. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/make.sh &&
  789. Xmkdir objects
  790. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O infer.c
  791. Xmv infer.o objects
  792. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O make.c
  793. Xmv make.o objects
  794. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O stat.c
  795. Xmv stat.o objects
  796. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O expand.c
  797. Xmv expand.o objects
  798. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O string.c
  799. Xmv string.o objects
  800. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O hash.c
  801. Xmv hash.o objects
  802. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O dag.c
  803. Xmv dag.o objects
  804. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O dmake.c
  805. Xmv dmake.o objects
  806. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O path.c
  807. Xmv path.o objects
  808. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O imacs.c
  809. Xmv imacs.o objects
  810. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O sysintf.c
  811. Xmv sysintf.o objects
  812. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O parse.c
  813. Xmv parse.o objects
  814. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O getinp.c
  815. Xmv getinp.o objects
  816. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O quit.c
  817. Xmv quit.o objects
  818. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O basename.c
  819. Xmv basename.o objects
  820. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O dump.c
  821. Xmv dump.o objects
  822. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O macparse.c
  823. Xmv macparse.o objects
  824. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O rulparse.c
  825. Xmv rulparse.o objects
  826. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O percent.c
  827. Xmv percent.o objects
  828. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O function.c
  829. Xmv function.o objects
  830. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/arlib.c
  831. Xmv arlib.o objects
  832. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/dirbrk.c
  833. Xmv dirbrk.o objects
  834. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/explode.c
  835. Xmv explode.o objects
  836. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/rmprq.c
  837. Xmv rmprq.o objects
  838. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/ruletab.c
  839. Xmv ruletab.o objects
  840. Xcc -c -DHELP -I. -Icommon -Iunix -Iunix/386ix -O unix/386ix/runargv.c
  841. Xmv runargv.o objects
  842. Xcc  -o dmake  objects/infer.o objects/make.o objects/stat.o objects/expand.o objects/string.o objects/hash.o objects/dag.o objects/dmake.o objects/path.o objects/imacs.o objects/sysintf.o objects/parse.o objects/getinp.o objects/quit.o objects/basename.o objects/dump.o objects/macparse.o objects/rulparse.o objects/percent.o objects/function.o objects/arlib.o objects/dirbrk.o objects/explode.o objects/rmprq.o objects/ruletab.o objects/runargv.o 
  843. SHAR_EOF
  844. chmod 0640 unix/386ix/make.sh || echo "restore of unix/386ix/make.sh fails"
  845. echo "x - extracting unix/386ix/config.mk (Text)"
  846. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/config.mk &&
  847. X# This is the 386IX UNIX configuration file for DMAKE
  848. X#    It simply modifies the values of SRC, and checks to see if
  849. X#    OSENVIRONMENT is defined.  If so it includes the appropriate
  850. X#    config.mk file.
  851. X#
  852. X# It also sets the values of .SOURCE.c and .SOURCE.h to include the local
  853. X# directory.
  854. X#
  855. Xosrdir := $(OS)$(DIRSEPSTR)$(OSRELEASE)
  856. X
  857. X# The following are required sources
  858. XOSDSRC := runargv.c
  859. XSRC    += $(OSDSRC)
  860. X.SETDIR=$(osrdir) : $(OSDSRC)
  861. X
  862. X.SOURCE.h : $(osrdir)
  863. X
  864. X# Local configuration modifications for CFLAGS, there's local SysV includes
  865. X# too.
  866. XCFLAGS += -I$(osrdir)
  867. X
  868. X# See if we modify anything in the lower levels.
  869. X.IF $(OSENVIRONMENT) != $(NULL)
  870. X   .INCLUDE .IGNORE : $(osrdir)$(DIRSEPSTR)$(OSENVIRONMENT)$(DIRSEPSTR)config.mk
  871. X.END
  872. SHAR_EOF
  873. chmod 0640 unix/386ix/config.mk || echo "restore of unix/386ix/config.mk fails"
  874. echo "x - extracting unix/386ix/config.h (Text)"
  875. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/config.h &&
  876. X/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/unix/386ix/RCS/config.h,v 1.1 90/10/06 12:05:52 dvadura Exp $
  877. X-- SYNOPSIS -- Configurarion include file.
  878. X-- 
  879. X-- DESCRIPTION
  880. X--     There is one of these for each specific machine configuration.
  881. X--    It can be used to further tweek the machine specific sources
  882. X--    so that they compile.
  883. X--
  884. X-- AUTHOR
  885. X--      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  886. X--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  887. X--
  888. X-- COPYRIGHT
  889. X--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  890. X-- 
  891. X--      This program is free software; you can redistribute it and/or
  892. X--      modify it under the terms of the GNU General Public License
  893. X--      (version 1), as published by the Free Software Foundation, and
  894. X--      found in the file 'LICENSE' included with this distribution.
  895. X-- 
  896. X--      This program is distributed in the hope that it will be useful,
  897. X--      but WITHOUT ANY WARRANTY; without even the implied warrant of
  898. X--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  899. X--      GNU General Public License for more details.
  900. X-- 
  901. X--      You should have received a copy of the GNU General Public License
  902. X--      along with this program;  if not, write to the Free Software
  903. X--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  904. X--
  905. X-- LOG
  906. X--     $Log:    config.h,v $
  907. X * Revision 1.1  90/10/06  12:05:52  dvadura
  908. X * dmake Release, Version 3.6
  909. X * 
  910. X*/
  911. X
  912. X/* define this for configurations that don't have the coreleft function
  913. X * so that the code compiles.  To my knowledge coreleft exists only on
  914. X * Turbo C, but it is needed here since the function is used in many debug
  915. X * macros. */
  916. X#define coreleft() 0L
  917. X
  918. X/* Define the getcwd function that is used in the code, since BSD does
  919. X * not have getcwd, but call it getwd instead. */
  920. Xextern char *getcwd ANSI((char *, int));
  921. X
  922. X/* Define setvbuf, SysV doesn't have one */
  923. X#define setvbuf(fp, bp, type, len) setbuf( fp, NULL );
  924. X
  925. X/* NCR Tower's don't define size_t */
  926. X#ifdef tower
  927. Xtypedef long size_t;
  928. X#endif
  929. SHAR_EOF
  930. chmod 0440 unix/386ix/config.h || echo "restore of unix/386ix/config.h fails"
  931. echo "x - extracting unix/386ix/ar.h (Text)"
  932. sed 's/^X//' << 'SHAR_EOF' > unix/386ix/ar.h &&
  933. X#define PORTAR 1
  934. X#include "/usr/include/ar.h"
  935. SHAR_EOF
  936. chmod 0440 unix/386ix/ar.h || echo "restore of unix/386ix/ar.h fails"
  937. echo "x - extracting sysintf.c (Text)"
  938. sed 's/^X//' << 'SHAR_EOF' > sysintf.c &&
  939. X/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/sysintf.c,v 1.1 90/10/06 12:04:17 dvadura Exp $
  940. X-- SYNOPSIS -- system independent interface
  941. X-- 
  942. X-- DESCRIPTION
  943. X--    These are the routines constituting the system interface.
  944. X--    The system is taken to be essentially POSIX conformant.
  945. X--    The original code was extensively revised by T J Thompson at MKS,
  946. X--    and the library cacheing was added by Eric Gisin at MKS.  I then
  947. X--    revised the code yet again, to improve the lib cacheing, and to
  948. X--    make it more portable.
  949. X--
  950. X--    The following is a list of routines that are required by this file
  951. X--    in order to work.  These routines are provided as functions by the
  952. X--    standard C lib of the target system or as #defines in system/sysintf.h
  953. X--    or via appropriate C code in the system/ directory for the given
  954. X--    system.
  955. X--
  956. X--    The first group must be provided by a file in the system/ directory
  957. X--    the second group is ideally provided by the C lib.  However, there
  958. X--    are instances where the C lib implementation of the specified routine
  959. X--    does not exist, or is incorrect.  In these instances the routine
  960. X--    must be provided by the the user in the system/ directory of dmake.
  961. X--    (For example, the bsd/ dir contains code for putenv(), and tempnam())
  962. X--
  963. X--    DMAKE SPECIFIC:
  964. X--        seek_arch()
  965. X--        touch_arch()
  966. X--        void_lcache()
  967. X--        runargv()
  968. X--        STAT()
  969. X--        Remove_prq()
  970. X--
  971. X--    C-LIB SPECIFIC:  (should be present in your C-lib)
  972. X--        utime()
  973. X--        time()
  974. X--        getenv()
  975. X--        putenv()
  976. X--        getcwd()
  977. X--        signal()
  978. X--        chdir()
  979. X--        tempnam()
  980. X-- 
  981. X-- AUTHOR
  982. X--      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  983. X--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  984. X--
  985. X-- COPYRIGHT
  986. X--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  987. X-- 
  988. X--      This program is free software; you can redistribute it and/or
  989. X--      modify it under the terms of the GNU General Public License
  990. X--      (version 1), as published by the Free Software Foundation, and
  991. X--      found in the file 'LICENSE' included with this distribution.
  992. X-- 
  993. X--      This program is distributed in the hope that it will be useful,
  994. X--      but WITHOUT ANY WARRANTY; without even the implied warrant of
  995. X--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  996. X--      GNU General Public License for more details.
  997. X-- 
  998. X--      You should have received a copy of the GNU General Public License
  999. X--      along with this program;  if not, write to the Free Software
  1000. X--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1001. X--
  1002. X-- LOG
  1003. X--     $Log:    sysintf.c,v $
  1004. X * Revision 1.1  90/10/06  12:04:17  dvadura
  1005. X * dmake Release, Version 3.6
  1006. X * 
  1007. X*/
  1008. X
  1009. X#include <stdio.h>
  1010. X#include "extern.h"
  1011. X#include "sysintf.h"
  1012. X#include "alloc.h"
  1013. X
  1014. X/*
  1015. X** Tries to stat the file name.  Returns 0 if the file
  1016. X** does not exist.  Note that if lib is not null it tries to stat
  1017. X** the name found inside lib.
  1018. X**
  1019. X** If member is NOT nil then look for the library object which defines the
  1020. X** symbol given by name.  If found _strdup the name and return make the
  1021. X** pointer pointed at by sym point at it.  Not handled for now!
  1022. X*/
  1023. Xtime_t
  1024. XDo_stat(name, lib, member)
  1025. Xchar *name;
  1026. Xchar *lib;
  1027. Xchar **member;
  1028. X{
  1029. X   struct stat buf;
  1030. X   time_t seek_arch();
  1031. X
  1032. X   if( member != NIL(char *) )
  1033. X      Fatal("Library symbol names not supported");
  1034. X
  1035. X   if( lib != NIL(char) )
  1036. X      return( seek_arch(basename(name), lib) );
  1037. X   else
  1038. X      return( (STAT(name, &buf) == -1) ? (time_t)0 : buf.st_mtime );
  1039. X}
  1040. X
  1041. X
  1042. X
  1043. X/* Touch existing file to force modify time to present.
  1044. X */
  1045. Xint
  1046. XDo_touch(name, lib, member)
  1047. Xchar *name;
  1048. Xchar *lib;
  1049. Xchar **member;
  1050. X{
  1051. X   if( member != NIL(char *) )
  1052. X      Fatal("Library symbol names not supported");
  1053. X
  1054. X   if (lib != NIL(char))
  1055. X      return( touch_arch(basename(name), lib) );
  1056. X   else
  1057. X      return( utime(name, NIL(time_t)) );
  1058. X}
  1059. X
  1060. X
  1061. X
  1062. Xvoid
  1063. XVoid_lib_cache( lib_name, member_name )/*
  1064. X=========================================
  1065. X   Void the library cache for lib lib_name, and member member_name. */
  1066. Xchar *lib_name;
  1067. Xchar *member_name;
  1068. X{
  1069. X   VOID_LCACHE( lib_name, member_name );
  1070. X}
  1071. X
  1072. X
  1073. X
  1074. X/*
  1075. X** return the current time
  1076. X*/
  1077. Xtime_t
  1078. XDo_time()
  1079. X{
  1080. X   extern time_t time();
  1081. X   return (time((time_t*)0));
  1082. X}
  1083. X
  1084. X
  1085. X
  1086. X/*
  1087. X** Execute the string passed in as a command and return
  1088. X** the return code. The command line arguments are
  1089. X** assumed to be separated by spaces or tabs.  The first
  1090. X** such argument is assumed to be the command.
  1091. X**
  1092. X** If group is true then this is a group of commands to be fed to the
  1093. X** the shell as a single unit.  In this case cmd is of the form
  1094. X** "file" indicating the file that should be read by the shell
  1095. X** in order to execute the command group.
  1096. X*/
  1097. Xint
  1098. XDo_cmnd(cmd, group, do_it, target, how, ignore, shell, last)
  1099. Xchar   *cmd;
  1100. Xint     group;
  1101. Xint    do_it;
  1102. XCELLPTR target;
  1103. XHOWPTR  how;
  1104. Xint     ignore;
  1105. Xint     shell;
  1106. Xint    last;
  1107. X{
  1108. X   int  i;
  1109. X
  1110. X   if( !do_it ) {
  1111. X      if( last && !Doing_bang ) Update_time_stamp( target, how );
  1112. X      return(0);
  1113. X   }
  1114. X
  1115. X   if( Max_proc == 1 ) Wait_for_completion = TRUE;
  1116. X   if( (i = runargv(target, how, ignore, group, last, shell, cmd)) == -1 )
  1117. X      Quit();
  1118. X
  1119. X   /* NOTE:  runargv must return either 0 or 1, 0 ==> command executed, and
  1120. X    * we waited for it to return, 1 ==> command started and is running
  1121. X    * concurrently with make process. */
  1122. X   return(i);
  1123. X}
  1124. X
  1125. X
  1126. X#define MINARGV 64
  1127. X/* Take a command and pack it into an argument vector to be executed. */
  1128. Xchar **
  1129. XPack_argv( group, shell, cmd )
  1130. Xint    group;
  1131. Xint    shell;
  1132. Xchar  *cmd;
  1133. X{
  1134. X   static char **av = NIL(char *);
  1135. X   static int   avs = 0;
  1136. X   int i = 0;
  1137. X
  1138. X   if( av == NIL(char *) ) {
  1139. X      TALLOC(av, MINARGV, char*);
  1140. X      avs = MINARGV;
  1141. X   }
  1142. X
  1143. X   if( (Packed_shell = shell||group||(*_strpbrk(cmd, Shell_metas)!='\0')) ) {
  1144. X      char* sh = group ? GShell : Shell;
  1145. X
  1146. X      if( sh != NIL(char) ) {
  1147. X         av[i++] = sh;
  1148. X         if( (av[i] = (group?GShell_flags:Shell_flags)) != NIL(char) ) i++;
  1149. X
  1150. X     av[i++] = cmd;
  1151. X     av[i]   = NIL(char);
  1152. X      }
  1153. X      else
  1154. X     Fatal("%sSHELL macro not defined", group?"GROUP":"");
  1155. X   }
  1156. X   else {
  1157. X      do {
  1158. X         while( iswhite(*cmd) ) ++cmd;
  1159. X         if( *cmd ) av[i++] = cmd;
  1160. X
  1161. X         while( *cmd != '\0' && !iswhite(*cmd) ) ++cmd;
  1162. X         if( *cmd ) *cmd++ = '\0';
  1163. X
  1164. X     if( i == avs ) {
  1165. X        avs += MINARGV;
  1166. X        av = (char **) realloc( av, avs*sizeof(char *) );
  1167. X     }
  1168. X      } while( *cmd );
  1169. X
  1170. X      av[i] = NIL(char);
  1171. X   }
  1172. X
  1173. X   return(av);
  1174. X}
  1175. X
  1176. X
  1177. X/*
  1178. X** Return the value of ename from the environment
  1179. X** if ename is not defined in the environment then
  1180. X** NIL(char) should be returned
  1181. X*/
  1182. Xchar *
  1183. XRead_env_string(ename)
  1184. Xchar *ename;
  1185. X{
  1186. X   extern char *getenv();
  1187. X   return( getenv(ename) );
  1188. X}
  1189. X
  1190. X
  1191. X
  1192. X/*
  1193. X** Set the value of the environment string ename to value.
  1194. X**  Returns 0 if success, non-zero if failure
  1195. X*/
  1196. Xint
  1197. XWrite_env_string(ename, value)
  1198. Xchar *ename;
  1199. Xchar *value;
  1200. X{
  1201. X   extern int putenv();
  1202. X   char*   p;
  1203. X   char*   envstr = _stradd(ename, value, FALSE);
  1204. X
  1205. X   p = envstr+strlen(ename);    /* Don't change this code, _stradd does not */
  1206. X   *p++ = '=';            /* add the space if *value is 0, it does    */
  1207. X   if( !*value ) *p = '\0';    /* allocate enough memory for one though.   */
  1208. X
  1209. X   return( putenv(envstr) );
  1210. X}
  1211. X
  1212. X
  1213. X
  1214. Xvoid
  1215. XReadEnvironment()
  1216. X{
  1217. X   extern char **Rule_tab;
  1218. X   extern char **environ;
  1219. X   char **rsave;
  1220. X
  1221. X   rsave    = Rule_tab;
  1222. X   Rule_tab = environ;
  1223. X   Readenv  = TRUE;
  1224. X
  1225. X   Parse( NIL(FILE) );
  1226. X
  1227. X   Readenv  = FALSE;
  1228. X   Rule_tab = rsave;
  1229. X}
  1230. X
  1231. X
  1232. X
  1233. X/*
  1234. X** All we have to catch is SIG_INT
  1235. X*/
  1236. Xvoid
  1237. XCatch_signals(fn)
  1238. Xvoid (*fn)();
  1239. X{
  1240. X   if( signal(SIGINT, SIG_IGN) != SIG_IGN )
  1241. X      signal( SIGINT, fn );
  1242. X   if( signal(SIGQUIT, SIG_IGN) != SIG_IGN )
  1243. X      signal( SIGQUIT, fn );
  1244. X}
  1245. X
  1246. X
  1247. X
  1248. X/*
  1249. X** Clear any previously set signals
  1250. X*/
  1251. Xvoid
  1252. XClear_signals()
  1253. X{
  1254. X   if( signal(SIGINT, SIG_IGN) != SIG_IGN )
  1255. X      signal( SIGINT, SIG_DFL );
  1256. X   if( signal(SIGQUIT, SIG_IGN) != SIG_IGN )
  1257. X      signal( SIGQUIT, SIG_DFL );
  1258. X}
  1259. X
  1260. X
  1261. X
  1262. X/*
  1263. X** Set program name
  1264. X*/
  1265. Xvoid
  1266. XProlog(argc, argv)
  1267. Xint   argc;
  1268. Xchar* argv[];
  1269. X{
  1270. X   Pname = (argc == 0) ? DEF_MAKE_PNAME : argv[0];
  1271. X   Root_how.hw_files = NIL(FILELIST);
  1272. X}
  1273. X
  1274. X
  1275. X
  1276. X/*
  1277. X** Do any clean up for exit.
  1278. X*/
  1279. Xvoid
  1280. XEpilog(ret_code)
  1281. Xint ret_code;
  1282. X{
  1283. X   Unlink_temp_files(&Root_how);
  1284. X   exit( ret_code );
  1285. X}
  1286. X
  1287. X
  1288. X
  1289. X/*
  1290. X** Use the built-in functions of the operating system to get the current
  1291. X** working directory.
  1292. X*/
  1293. Xchar *
  1294. XGet_current_dir()
  1295. X{
  1296. X   static char buf[MAX_PATH_LEN+1];
  1297. X
  1298. X   return( getcwd(buf, sizeof(buf)) );
  1299. X}
  1300. X
  1301. X
  1302. X
  1303. X/*
  1304. X** change working directory
  1305. X*/
  1306. Xint
  1307. XSet_dir(path)
  1308. Xchar*   path;
  1309. X{
  1310. X   return( chdir(path) );
  1311. X}
  1312. X
  1313. X
  1314. X
  1315. X/*
  1316. X** return switch char
  1317. X*/
  1318. Xchar
  1319. XGet_switch_char()
  1320. X{
  1321. X   return( getswitchar() );
  1322. X}
  1323. X
  1324. X
  1325. X
  1326. X/*
  1327. X** Generate a temporary file name and open the file for writing.
  1328. X** If a name cannot be generated or the file cannot be opened
  1329. X** return -1, else return the fileno of the open file.
  1330. X** and update the source file pointer to point at the new file name.
  1331. X** Note that the new name should be freed when the file is removed.
  1332. X*/
  1333. XFILE*
  1334. XOpen_temp(path, suff)
  1335. Xchar **path;
  1336. Xchar *suff;
  1337. X{
  1338. X   extern char *tempnam();
  1339. X
  1340. X   *path = _strjoin( tempnam(NIL(char), "mk"), suff, -1, TRUE );
  1341. X   Def_macro( "TMPFILE", *path, M_MULTI|M_EXPANDED );
  1342. X
  1343. X   return( fopen(*path, "w") );
  1344. X}
  1345. X
  1346. X
  1347. X/*
  1348. X** Open a new temporary file and set it up for writing.
  1349. X*/
  1350. XFILE *
  1351. XStart_temp( suffix, cp, how, fname )
  1352. Xchar     *suffix;
  1353. XCELLPTR   cp;
  1354. XHOWPTR    how;
  1355. Xchar    **fname;
  1356. X{
  1357. X   FILE           *fp;
  1358. X   char        *tmpname;
  1359. X   char           *name;
  1360. X   FILELISTPTR new;
  1361. X
  1362. X   name = (cp != NIL(CELL))?cp->CE_NAME:"makefile text";
  1363. X   if( how == NIL(HOW) ) how = &Root_how;
  1364. X
  1365. X   if( (fp = Open_temp( &tmpname, suffix)) == NIL(FILE) )
  1366. X      Fatal("Cannot open temp file `%s' while processing `%s'", tmpname, name );
  1367. X
  1368. X   TALLOC( new, 1, FILELIST );
  1369. X
  1370. X   new->fl_next = how->hw_files;
  1371. X   new->fl_name = tmpname;
  1372. X   new->fl_file = fp;        /* indicates temp file is open */
  1373. X
  1374. X   how->hw_files = new;
  1375. X   *fname = tmpname;
  1376. X
  1377. X   return( fp );
  1378. X}
  1379. X
  1380. X
  1381. X/*
  1382. X** Close a previously used temporary file.
  1383. X*/
  1384. Xvoid
  1385. XClose_temp(how, file)
  1386. XHOWPTR  how;
  1387. XFILE    *file;
  1388. X{
  1389. X   FILELISTPTR fl;
  1390. X   if( how == NIL(HOW) ) how = &Root_how;
  1391. X
  1392. X   for( fl=how->hw_files; fl && fl->fl_file != file; fl=fl->fl_next );
  1393. X   if( fl ) {
  1394. X      fl->fl_file = NIL(FILE);
  1395. X      fclose(file);
  1396. X   }
  1397. X}
  1398. X
  1399. X
  1400. X/*
  1401. X** Clean-up, and close all temporary files associated with a target.
  1402. X*/
  1403. Xvoid
  1404. XUnlink_temp_files( how )/*
  1405. X==========================
  1406. X   Unlink the tempfiles if any exist.  Make sure you close the files first
  1407. X   though.  This ensures that under DOS there is no disk space lost. */
  1408. XHOWPTR how;
  1409. X{
  1410. X   FILELISTPTR next;
  1411. X
  1412. X   while( how->hw_files != NIL(FILELIST) ) {
  1413. X      if( how->hw_files->fl_file ) fclose( how->hw_files->fl_file );
  1414. X
  1415. X      if( Verbose )
  1416. X         printf( "%s:  Left temp file [%s]\n", Pname, how->hw_files->fl_name );
  1417. X      else
  1418. X         (void) unlink( how->hw_files->fl_name );
  1419. X
  1420. X      FREE( how->hw_files->fl_name );
  1421. X      next = how->hw_files->fl_next;
  1422. X      FREE(how->hw_files);
  1423. X      how->hw_files = next;
  1424. X   }
  1425. X}
  1426. X
  1427. X
  1428. Xvoid
  1429. XHandle_result(status, ignore, abort_flg, target)
  1430. Xint    status;
  1431. Xint    ignore;
  1432. Xint    abort_flg;
  1433. XCELLPTR target;
  1434. X{
  1435. X   status = ((status&0xff)==0 ? status>>8
  1436. X        : (status & 0xff)==SIGTERM ? -1
  1437. X        : (status & 0x7f)+128);
  1438. X
  1439. X   if( status )
  1440. X      if( !abort_flg ) {
  1441. X     fprintf( stderr, "%s:  Error code %d, while making '%s'",
  1442. X          Pname, status, target->ce_fname );
  1443. X
  1444. X     if( ignore || Continue ) {
  1445. X        fputs( " (Ignored)\n", stderr );
  1446. X     }
  1447. X     else {
  1448. X        fputc( '\n', stderr );
  1449. X
  1450. X        if( !(target->ce_attr & A_PRECIOUS) )
  1451. X           if( unlink( target->ce_fname ) == 0 )
  1452. X          fprintf(stderr,"%s:  '%s' removed.\n",Pname,target->ce_fname);
  1453. X
  1454. X        Quit();
  1455. X     }
  1456. X      }
  1457. X      else if( !(target->ce_attr & A_PRECIOUS) )
  1458. X     unlink( target->ce_fname );
  1459. X}
  1460. X
  1461. X
  1462. Xvoid
  1463. XUpdate_time_stamp( cp, how )
  1464. XCELLPTR cp;
  1465. XHOWPTR  how;
  1466. X{
  1467. X   HASHPTR hp;
  1468. X   CELLPTR tcp;
  1469. X   int     tmpflg; 
  1470. X
  1471. X   how->hw_flag |= F_MADE;
  1472. X   Unlink_temp_files( how );
  1473. X
  1474. X   /* do the time only at end, of MULTI recipe targets, or immediately
  1475. X    * for non-MULTI recipe targets. */
  1476. X   tmpflg = cp->ce_flag & F_MULTI;
  1477. X
  1478. X   if( (tmpflg && cp->CE_HOW == how) || !tmpflg ) {
  1479. X      tcp = cp;
  1480. X      do {
  1481. X     if( tcp->ce_attr & A_LIBRARY )
  1482. X        Void_lib_cache( tcp->ce_fname, NIL(char) );
  1483. X     else if( !Touch && (tcp->ce_attr & A_LIBRARYM) )
  1484. X        Void_lib_cache( tcp->ce_lib, tcp->ce_fname );
  1485. X
  1486. X     if( Trace ) {
  1487. X        tcp->ce_time  = Do_time();
  1488. X        tcp->ce_flag |= F_STAT;        /* pretend we stated ok */
  1489. X
  1490. X        if( tcp->ce_fname == NIL(char) )
  1491. X           tcp->ce_fname = tcp->CE_NAME;
  1492. X     }
  1493. X     else {
  1494. X        Stat_target( tcp, TRUE );
  1495. X        if( tcp->ce_time == (time_t) 0L )
  1496. X           tcp->ce_time = Do_time();
  1497. X     }
  1498. X
  1499. X     if( Verbose )
  1500. X        printf( "%s:  <<<< Set [%s] time stamp to %ld\n",
  1501. X            Pname, tcp->CE_NAME, tcp->ce_time );
  1502. X
  1503. X     tcp->ce_flag |= F_MADE;
  1504. X     tcp = tcp->ce_all;
  1505. X      }
  1506. X      while( tcp != NIL(CELL) && tcp != cp );
  1507. X   }
  1508. X   else if( tmpflg )
  1509. X      cp->ce_flag |= F_STAT;
  1510. X
  1511. X
  1512. X   /* Scan the list of prerequisites and if we find one that is
  1513. X    * marked as being removable, (ie. an inferred intermediate node
  1514. X    * then remove it.  We remove a prerequisite by running the recipe
  1515. X    * associated with the special target .REMOVE, with $< set to
  1516. X    * the list of prerequisites to remove. */
  1517. X
  1518. X   if( (hp = Get_name( ".REMOVE", Defs, FALSE, NIL(CELL) )) != NIL(HASH) ) {
  1519. X      register LINKPTR dp;
  1520. X      int flag = FALSE;
  1521. X      int rem;
  1522. X      t_attr attr;
  1523. X
  1524. X      tcp = hp->CP_OWNR;
  1525. X      tcp->ce_flag |= F_TARGET;
  1526. X      Clear_prerequisites( tcp->CE_HOW );
  1527. X
  1528. X      for( dp = how->hw_prq; dp != NIL(LINK); dp = dp->cl_next ) {
  1529. X     register CELLPTR prq = dp->cl_prq;
  1530. X
  1531. X     attr = Glob_attr | prq->ce_attr;
  1532. X     rem  = (prq->ce_flag & F_REMOVE) &&
  1533. X        (prq->ce_flag & F_MADE  ) &&
  1534. X        !(attr & A_PRECIOUS) &&
  1535. X        !Force;
  1536. X
  1537. X     if( rem ) {
  1538. X        CELLPTR tmp = prq;
  1539. X        do {
  1540. X           (Add_prerequisite(tcp->CE_HOW, prq, FALSE))->cl_flag |= F_TARGET;
  1541. X           prq->ce_flag &= ~F_REMOVE;
  1542. X           prq = prq->ce_all;
  1543. X        }
  1544. X        while( prq != NIL(CELL) && prq != tmp );
  1545. X        flag = TRUE;
  1546. X     }
  1547. X      }
  1548. X
  1549. X      if( flag ) Remove_prq( tcp );
  1550. SHAR_EOF
  1551. echo "End of part 4"
  1552. echo "File sysintf.c is continued in part 5"
  1553. echo "5" > s2_seq_.tmp
  1554. exit 0
  1555.  
  1556.